home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / File / Find.php < prev    next >
PHP Script  |  2004-03-24  |  9KB  |  331 lines
  1. <?php
  2. //
  3. // +----------------------------------------------------------------------+
  4. // | PHP Version 4                                                        |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997-2002 The PHP Group                                |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 2.02 of the PHP license,      |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/2_02.txt.                                 |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Author: Sterling Hughes <sterling@php.net>                           |
  17. // +----------------------------------------------------------------------+
  18. //
  19. // $Id: Find.php,v 1.1 2002/10/24 21:31:57 tuupola Exp $
  20. //
  21.  
  22. require_once 'PEAR.php';
  23.  
  24. /**
  25. *  Commonly needed functions searching directory trees
  26. *
  27. * @access public
  28. * @version $Id: Find.php,v 1.1 2002/10/24 21:31:57 tuupola Exp $
  29. * @package File
  30. * @author Sterling Hughes <sterling@php.net>
  31. */
  32. class File_Find
  33. {
  34.     /**
  35.     * internal dir-list
  36.     * @var array
  37.     */
  38.     var $_dirs       = array ();
  39.     /**
  40.     * founded files
  41.     * @var array
  42.     */
  43.     var $files       = array ();
  44.     /**
  45.     * founded dirs
  46.     * @var array
  47.     */
  48.     var $directories = array ();
  49.  
  50.     /**
  51.      * Search the current directory to find matches for the
  52.      * the specified pattern.
  53.      *
  54.      * @param string $pattern a string containing the pattern to search
  55.      * the directory for.
  56.      *
  57.      * @param string $dirpath a string containing the directory path
  58.      * to search.
  59.      *
  60.      * @param string $pattern_type a string containing the type of
  61.      * pattern matching functions to use (can either be 'php' or
  62.      * 'perl').
  63.      *
  64.      * @return array containing all of the files and directories
  65.      * matching the pattern or null if no matches
  66.      *
  67.      * @author Sterling Hughes <sterling@php.net>
  68.      * @access public
  69.      */
  70.     function &glob ($pattern, $dirpath, $pattern_type='php')
  71.     {
  72.         $dh = @opendir ($dirpath);
  73.  
  74.         if (!$dh) {
  75.             $pe = new FileFindException("Cannot open directory");
  76.             return ($pe);
  77.         }
  78.  
  79.         $match_function = File_Find::_determineRegex($pattern, $pattern_type);
  80.         $matches = array();
  81.         while ($entry = @readdir ($dh)) {
  82.             if ($match_function($pattern, $entry) &&
  83.                 $entry != '.'                     &&
  84.                 $entry != '..') {
  85.                 $matches[] = $entry;
  86.             }
  87.         }
  88.  
  89.         @closedir ($dh);
  90.         return count($matches) > 0 ? $matches : null;
  91.     }
  92.  
  93.     /**
  94.      * Map the directory tree given by the directory_path parameter.
  95.      *
  96.      * @param string $directory contains the directory path that you
  97.      * want to map.
  98.      *
  99.      * @return array a two element array, the first element containing a list
  100.      * of all the directories, the second element containing a list of all the
  101.      * files.
  102.      *
  103.      * @author Sterling Hughes <sterling@php.net>
  104.      * @access public
  105.      */
  106.     function &maptree ($directory)
  107.     {
  108.         $this->_dirs = array($directory);
  109.  
  110.         while (count($this->_dirs)) {
  111.             $dir = array_pop($this->_dirs);
  112.             File_Find::_build($dir);
  113.             array_push($this->directories, $dir);
  114.         }
  115.  
  116.         return array($this->directories, $this->files);
  117.     }
  118.  
  119.     /**
  120.      * Map the directory tree given by the directory parameter.
  121.      *
  122.      * @param string $directory contains the directory path that you
  123.      * want to map.
  124.      * @param integer $maxrecursion maximun number of folders to recursive 
  125.      * map
  126.      *
  127.      * @return array a multidimensional array containing all subdirectories
  128.      * and their files. For example:
  129.      *
  130.      * Array
  131.      * (
  132.      *    [0] => file_1.php
  133.      *    [1] => file_2.php
  134.      *    [subdirname] => Array
  135.      *       (
  136.      *          [0] => file_1.php
  137.      *       )
  138.      * )
  139.      *
  140.      * @author Mika Tuupola <tuupola@appelsiini.net>
  141.      * @access public
  142.      */
  143.  
  144.     function &mapTreeMultiple($directory, $maxrecursion=0, $count=0)
  145.     {   
  146.  
  147.         $retval = array();
  148.  
  149.         $count++;
  150.  
  151.         $directory .= DIRECTORY_SEPARATOR;
  152.         $dh=opendir($directory);
  153.         while ($entry = readdir($dh)) {
  154.             if ($entry != "." && $entry != "..") {
  155.                  array_push($retval, $entry);
  156.             }
  157.         }
  158.  
  159.         closedir($dh);
  160.      
  161.         while (list($key, $val) = each($retval)) {
  162.             $path = $directory . $val;
  163.             $path = str_replace(DIRECTORY_SEPARATOR.DIRECTORY_SEPARATOR,
  164.                                 DIRECTORY_SEPARATOR, $path);
  165.       
  166.             if (!(is_array($val))) {
  167.                 if (is_dir($path)) {
  168.                     unset($retval[$key]);
  169.                     if ($maxrecursion == 0 || $count < $maxrecursion) {
  170.                         $retval[$val] = File_Find::mapTreeMultiple($path, 
  171.                                         $maxrecursion, $count);
  172.                     }
  173.                 }
  174.             }
  175.         }
  176.         return($retval);
  177.     }
  178.  
  179.     /**
  180.      * Search the specified directory tree with the specified pattern.  Return an
  181.      * array containing all matching files (no directories included).
  182.      *
  183.      * @param string $pattern the pattern to match every file with.
  184.      *
  185.      * @param string $directory the directory tree to search in.
  186.      *
  187.      * @param string $type the type of regular expression support to use, either
  188.      * 'php' or 'perl'.
  189.      *
  190.      * @return array a list of files matching the pattern parameter in the the directory
  191.      * path specified by the directory parameter
  192.      *
  193.      * @author Sterling Hughes <sterling@php.net>
  194.      * @access public
  195.      */
  196.     function &search ($pattern, $directory, $type='php') {
  197.         $matches = array();
  198.         list (,$files)  = File_Find::maptree($directory);
  199.         $match_function = File_Find::_determineRegex($pattern, $type);
  200.  
  201.         reset($files);
  202.         while (list(,$entry) = each($files)) {
  203.             if ($match_function($pattern, $entry))
  204.                 $matches[] = $entry;
  205.         }
  206.  
  207.         return ($matches);
  208.     }
  209.     /**
  210.      * Determine whether or not a variable is a PEAR exception
  211.      *
  212.      * @param object PEAR_Error $var the variable to test.
  213.      *
  214.      * @return boolean returns true if the variable is a PEAR error, otherwise
  215.      * it returns false.
  216.      * @access public
  217.      */
  218.     function isError (&$var)
  219.     {
  220.         return PEAR::isError($var);
  221.     }
  222.  
  223.     /**
  224.      * Fetch the current File_Find version
  225.      *
  226.      * @return string the current File_Find version.
  227.      * @access public
  228.      */
  229.     function File_Find_version()
  230.     {
  231.          return 1.1;
  232.     }
  233.     /**
  234.      * internal function to build singular directory trees, used by
  235.      * File_Find::maptree()
  236.      *
  237.      * @param string $directory name of the directory to read
  238.      * @return void
  239.      */
  240.     function _build ($directory)
  241.     {
  242.         $dh = @opendir ($directory);
  243.  
  244.         if (!$dh) {
  245.             $pe = new FileFindException("Cannot open directory");
  246.             return $pe;
  247.         }
  248.  
  249.         while ($entry = @readdir($dh)) {
  250.             if ($entry != '.' &&
  251.                 $entry != '..') {
  252.  
  253.                 $entry = $directory.DIRECTORY_SEPARATOR.$entry;
  254.  
  255.                 if (is_dir($entry))
  256.                     array_push($this->_dirs, $entry);
  257.                 else
  258.                     array_push($this->files, $entry);
  259.  
  260.             }
  261.  
  262.         }
  263.  
  264.         @closedir($dh);
  265.     }
  266.  
  267.     /**
  268.      * internal function to determine the type of regular expression to
  269.      * use, implemented by File_Find::glob() and File_Find::search()
  270.      *
  271.      * @param string $type given RegExp type
  272.      * @return string kind of function ( "eregi", "ereg" or "preg_match") ;
  273.      *
  274.      */
  275.     function _determineRegex ($pattern, $type)
  276.     {
  277.         if (! strcasecmp($type, 'perl')) {
  278.             $match_function = 'preg_match';
  279.         } else if (! strcasecmp(substr($pattern, -2), '/i')) {
  280.             $match_function = 'eregi';
  281.         } else {
  282.             $match_function = 'ereg';
  283.         }
  284.  
  285.         return $match_function;
  286.     }
  287.  
  288. //End Class
  289. }
  290. /**
  291. * Exception Class for Errorhandling of File_Find
  292. * @access public
  293. */
  294. class FileFindException extends PEAR_Error
  295. {
  296.     /**
  297.     * classname
  298.     * @var string
  299.     */
  300.     var $classname             = 'FileFindException';
  301.     /**
  302.     * Message in front of the error message
  303.     * @var string
  304.     */
  305.     var $error_message_prepend = 'Error in File_Find';
  306.     /**
  307.     * Creates a PEAR_Error object
  308.     *
  309.     * @param string $message    Error message
  310.     * @param int    $mode       Error mode
  311.     * @param int    $level      Error level
  312.     *
  313.     * @return object PEAR_Error
  314.     * @access public
  315.     */
  316.     function FileFindException ($message, $mode = PEAR_ERROR_RETURN, $level = E_USER_NOTICE)
  317.     {
  318.         $this->PEAR_Error($message, $mode, $level);
  319.     }
  320. }
  321.  
  322.  
  323. /*
  324.  * Local variables:
  325.  * tab-width: 4
  326.  * c-basic-offset: 4
  327.  * End:
  328.  */
  329.  
  330. ?>
  331.